﻿#ifndef _OSS_LOCK_H_
#define _OSS_LOCK_H_
#include "ossType.h"

OSS_EXTERN_BEG

/**
 *      创建互斥量
 */
Handle OssCreateMutex();

/**
 *      释放互斥量
 */
Bool OssFreeMutex(Handle hMutex);

/**
 *      互斥量上锁
 */
Bool OssLockMutex(Handle hMutex);

/**
 *      互斥量尝试上锁
 */
Bool OssTryLockMutex(Handle hMutex,DWord dwMilliseconds);

/**
 *      互斥量解锁
 */
Bool OssUnlockMutex(Handle hMutex);

/**
 *      创建信号量
 *@iInitVal     信号量的初始值
 *@iMaxVal      信号量的最大值
 *@return       成功返回 信号量句柄
 *              失败返回 NULL
 */
Handle OssCreateSemaphore(int iInitVal,int iMaxVal);

/**
 *      等待信号量(PV操作)
 *@hSem         信号量句柄，OssCreateSemaphore返回值
 *@dwTimeout    超时时间，单位毫秒
 *@return       等待到信号量返回 TRUE
 *              否则返回 FALSE
 */
Bool OssWaitForSemaphore(Handle hSem,DWord dwTimeout /*= OSS_INFINITE_TIME*/);

/**
 *      释放信号量(PV操作)
 *@hSem         信号量句柄，OssCreateSemaphore返回值
 *@return       成功返回 TRUE
 *              失败返回 FALSE
 */
Bool OssReleaseSemaphore(Handle hSem);

/**
 *      关闭信号量句柄
 *@hSem     信号量句柄,OssCreateSemaphore返回值
 *@return   成功释放返回 TRUE
 *          失败返回 FALSE
 */
Bool OssFreeSemaphore(Handle hSem);


OSS_EXTERN_END

#ifdef __cplusplus
/**
 *      互斥量类
 */
class OssMutex
{
public:
    OssMutex();
    virtual ~OssMutex();

    /**
     *      上锁
     */
    Bool Lock();

    /**
     *      解锁
     */
    Bool Unlock();

	Bool TryLock(DWord dwTimeout);
private:
    Handle  m_hMutex;
};

/**
 *      自动互斥量
 */
class OssAutoMutex
{
public :
    OssAutoMutex(OssMutex& cMutex);
    ~OssAutoMutex();

private:
    OssMutex    &m_cMutex;
};


/**
 *		临界区
 */
class OssCritical
{
public:
	OssCritical();
	virtual ~OssCritical();
	void EnterCritical();
	void LeaveCritical();

    //初始化变量
    void InitCritical();
private:
	Handle m_hcs;
};

/**
 *		自动临界区
 */
class OssAutoCritical
{
public:
	OssAutoCritical(OssCritical& critical)
		:m_critical(critical)
	{
		// 在进入多线程环境之前，初始化临界区  
		m_critical.EnterCritical();
	}
	virtual ~OssAutoCritical()
	{
		m_critical.LeaveCritical();
	}
private:
	OssCritical&	m_critical;
};

class OssSemaphore
{
public:
    OssSemaphore(int iInitVal,int iMaxVal);
    virtual ~OssSemaphore();

    /**
    *      等待信号量
    *@dwTimeout    超时时间，单位毫秒
    *@return       等待到信号量返回 TRUE
    *              否则返回 FALSE
    */
    Bool WaitForSemaphore(DWord dwTimeout = OSS_INFINITE_TIME);

    /**
     *      释放信号量
     *@return       成功返回 TRUE
     *              失败返回 FALSE
     */
    Bool ReleaseSemaphore();

private:
    Handle  m_hSem;
};

#endif//#ifdef __cplusplus
#endif